//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS VPCLattice service.
///
/// Amazon VPC Lattice is a fully managed application networking service that you use to connect, secure, and monitor all of your services across multiple accounts and virtual private clouds (VPCs). Amazon VPC Lattice interconnects your microservices and legacy services within a logical boundary, so that you can discover and manage them more efficiently. For more information, see the Amazon VPC Lattice User Guide
public struct VPCLattice: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the VPCLattice client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "VPCLattice",
            serviceIdentifier: "vpc-lattice",
            serviceProtocol: .restjson,
            apiVersion: "2022-11-30",
            endpoint: endpoint,
            errorType: VPCLatticeErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Updates the listener rules in a batch. You can use this operation to change the priority of listener rules. This can be useful when bulk updating or swapping rule priority.  Required permissions: vpc-lattice:UpdateRule  For more information, see How Amazon VPC Lattice works with IAM in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func batchUpdateRule(_ input: BatchUpdateRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchUpdateRuleResponse {
        try await self.client.execute(
            operation: "BatchUpdateRule", 
            path: "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the listener rules in a batch. You can use this operation to change the priority of listener rules. This can be useful when bulk updating or swapping rule priority.  Required permissions: vpc-lattice:UpdateRule  For more information, see How Amazon VPC Lattice works with IAM in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - listenerIdentifier: The ID or ARN of the listener.
    ///   - rules: The rules for the specified listener.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchUpdateRule(
        listenerIdentifier: String,
        rules: [RuleUpdate],
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchUpdateRuleResponse {
        let input = BatchUpdateRuleRequest(
            listenerIdentifier: listenerIdentifier, 
            rules: rules, 
            serviceIdentifier: serviceIdentifier
        )
        return try await self.batchUpdateRule(input, logger: logger)
    }

    /// Enables access logs to be sent to Amazon CloudWatch, Amazon S3, and Amazon Kinesis Data Firehose. The service network owner can use the access logs to audit the services in the network. The service network owner can only see access logs from clients and services that are associated with their service network. Access log entries represent traffic originated from VPCs associated with that network. For more information, see Access logs in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func createAccessLogSubscription(_ input: CreateAccessLogSubscriptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAccessLogSubscriptionResponse {
        try await self.client.execute(
            operation: "CreateAccessLogSubscription", 
            path: "/accesslogsubscriptions", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables access logs to be sent to Amazon CloudWatch, Amazon S3, and Amazon Kinesis Data Firehose. The service network owner can use the access logs to audit the services in the network. The service network owner can only see access logs from clients and services that are associated with their service network. Access log entries represent traffic originated from VPCs associated with that network. For more information, see Access logs in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - destinationArn: The Amazon Resource Name (ARN) of the destination. The supported destination types are CloudWatch Log groups, Kinesis Data Firehose delivery streams, and Amazon S3 buckets.
    ///   - resourceIdentifier: The ID or ARN of the service network or service.
    ///   - serviceNetworkLogType: The type of log that monitors your Amazon VPC Lattice service networks.
    ///   - tags: The tags for the access log subscription.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAccessLogSubscription(
        clientToken: String? = CreateAccessLogSubscriptionRequest.idempotencyToken(),
        destinationArn: String,
        resourceIdentifier: String,
        serviceNetworkLogType: ServiceNetworkLogType? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAccessLogSubscriptionResponse {
        let input = CreateAccessLogSubscriptionRequest(
            clientToken: clientToken, 
            destinationArn: destinationArn, 
            resourceIdentifier: resourceIdentifier, 
            serviceNetworkLogType: serviceNetworkLogType, 
            tags: tags
        )
        return try await self.createAccessLogSubscription(input, logger: logger)
    }

    /// Creates a listener for a service. Before you start using your Amazon VPC Lattice service, you must add one or more listeners. A listener is a process that checks for connection requests to your services. For more information, see Listeners in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func createListener(_ input: CreateListenerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateListenerResponse {
        try await self.client.execute(
            operation: "CreateListener", 
            path: "/services/{serviceIdentifier}/listeners", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a listener for a service. Before you start using your Amazon VPC Lattice service, you must add one or more listeners. A listener is a process that checks for connection requests to your services. For more information, see Listeners in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - defaultAction: The action for the default rule. Each listener has a default rule. The default rule is used if no other rules match.
    ///   - name: The name of the listener. A listener name must be unique within a service. The valid characters are a-z, 0-9, and hyphens (-). You can't use a hyphen as the first or last character, or immediately after another hyphen.
    ///   - port: The listener port. You can specify a value from 1 to 65535. For HTTP, the default is 80. For HTTPS, the default is 443.
    ///   - protocol: The listener protocol.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - tags: The tags for the listener.
    ///   - logger: Logger use during operation
    @inlinable
    public func createListener(
        clientToken: String? = CreateListenerRequest.idempotencyToken(),
        defaultAction: RuleAction,
        name: String,
        port: Int? = nil,
        protocol: ListenerProtocol,
        serviceIdentifier: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateListenerResponse {
        let input = CreateListenerRequest(
            clientToken: clientToken, 
            defaultAction: defaultAction, 
            name: name, 
            port: port, 
            protocol: `protocol`, 
            serviceIdentifier: serviceIdentifier, 
            tags: tags
        )
        return try await self.createListener(input, logger: logger)
    }

    /// Creates a resource configuration. A resource configuration defines a specific resource. You can associate a resource configuration with a service network or a VPC endpoint.
    @Sendable
    @inlinable
    public func createResourceConfiguration(_ input: CreateResourceConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateResourceConfigurationResponse {
        try await self.client.execute(
            operation: "CreateResourceConfiguration", 
            path: "/resourceconfigurations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a resource configuration. A resource configuration defines a specific resource. You can associate a resource configuration with a service network or a VPC endpoint.
    ///
    /// Parameters:
    ///   - allowAssociationToShareableServiceNetwork: (SINGLE, GROUP, ARN) Specifies whether the resource configuration can be associated with a sharable service network. The default is false.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - name: The name of the resource configuration. The name must be unique within the account. The valid characters are a-z, 0-9, and hyphens (-). You can't use a hyphen as the first or last character, or immediately after another hyphen.
    ///   - portRanges: (SINGLE, GROUP, CHILD) The TCP port ranges that a consumer can use to access a resource configuration (for example: 1-65535). You can separate port ranges using commas (for example: 1,2,22-30).
    ///   - protocol: (SINGLE, GROUP) The protocol accepted by the resource configuration.
    ///   - resourceConfigurationDefinition: Identifies the resource configuration in one of the following ways:    Amazon Resource Name (ARN) - Supported resource-types that are provisioned by Amazon Web Services services, such as RDS databases, can be identified by their ARN.    Domain name - Any domain name that is publicly resolvable.    IP address - For IPv4 and IPv6, only IP addresses in the VPC are supported.
    ///   - resourceConfigurationGroupIdentifier: (CHILD) The ID or ARN of the parent resource configuration of type GROUP. This is used to associate a child resource configuration with a group resource configuration.
    ///   - resourceGatewayIdentifier: (SINGLE, GROUP, ARN) The ID or ARN of the resource gateway used to connect to the resource configuration. For a child resource configuration, this value is inherited from the parent resource configuration.
    ///   - tags: The tags for the resource configuration.
    ///   - type: The type of resource configuration. A resource configuration can be one of the following types:    SINGLE - A single resource.    GROUP - A group of resources. You must create a group resource configuration before you create a child resource configuration.    CHILD - A single resource that is part of a group resource configuration.    ARN - An Amazon Web Services resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createResourceConfiguration(
        allowAssociationToShareableServiceNetwork: Bool? = nil,
        clientToken: String? = CreateResourceConfigurationRequest.idempotencyToken(),
        name: String,
        portRanges: [String]? = nil,
        protocol: ProtocolType? = nil,
        resourceConfigurationDefinition: ResourceConfigurationDefinition? = nil,
        resourceConfigurationGroupIdentifier: String? = nil,
        resourceGatewayIdentifier: String? = nil,
        tags: [String: String]? = nil,
        type: ResourceConfigurationType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateResourceConfigurationResponse {
        let input = CreateResourceConfigurationRequest(
            allowAssociationToShareableServiceNetwork: allowAssociationToShareableServiceNetwork, 
            clientToken: clientToken, 
            name: name, 
            portRanges: portRanges, 
            protocol: `protocol`, 
            resourceConfigurationDefinition: resourceConfigurationDefinition, 
            resourceConfigurationGroupIdentifier: resourceConfigurationGroupIdentifier, 
            resourceGatewayIdentifier: resourceGatewayIdentifier, 
            tags: tags, 
            type: type
        )
        return try await self.createResourceConfiguration(input, logger: logger)
    }

    /// A resource gateway is a point of ingress into the VPC where a resource resides. It spans multiple Availability Zones. For your resource to be accessible from all Availability Zones, you should create your resource gateways to span as many Availability Zones as possible. A VPC can have multiple resource gateways.
    @Sendable
    @inlinable
    public func createResourceGateway(_ input: CreateResourceGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateResourceGatewayResponse {
        try await self.client.execute(
            operation: "CreateResourceGateway", 
            path: "/resourcegateways", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// A resource gateway is a point of ingress into the VPC where a resource resides. It spans multiple Availability Zones. For your resource to be accessible from all Availability Zones, you should create your resource gateways to span as many Availability Zones as possible. A VPC can have multiple resource gateways.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - ipAddressType: A resource gateway can have IPv4, IPv6 or dualstack addresses. The IP address type of a resource gateway must be compatible with the subnets of the resource gateway and the IP address type of the resource, as described here:     IPv4Assign IPv4 addresses to your resource gateway network interfaces. This option is supported only if all selected subnets have IPv4 address ranges, and the resource also has an IPv4 address.    IPv6Assign IPv6 addresses to your resource gateway network interfaces. This option is supported only if all selected subnets are IPv6 only subnets, and the resource also has an IPv6 address.    DualstackAssign both IPv4 and IPv6 addresses to your resource gateway network interfaces. This option is supported only if all selected subnets have both IPv4 and IPv6 address ranges, and the resource either has an IPv4 or IPv6 address.   The IP address type of the resource gateway is independent of the IP address type of the client or the VPC endpoint through which the resource is accessed.
    ///   - ipv4AddressesPerEni: The number of IPv4 addresses in each ENI for the resource gateway.
    ///   - name: The name of the resource gateway.
    ///   - securityGroupIds: The IDs of the security groups to apply to the resource gateway. The security groups must be in the same VPC.
    ///   - subnetIds: The IDs of the VPC subnets in which to create the resource gateway.
    ///   - tags: The tags for the resource gateway.
    ///   - vpcIdentifier: The ID of the VPC for the resource gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func createResourceGateway(
        clientToken: String? = CreateResourceGatewayRequest.idempotencyToken(),
        ipAddressType: ResourceGatewayIpAddressType? = nil,
        ipv4AddressesPerEni: Int? = nil,
        name: String,
        securityGroupIds: [String]? = nil,
        subnetIds: [String]? = nil,
        tags: [String: String]? = nil,
        vpcIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateResourceGatewayResponse {
        let input = CreateResourceGatewayRequest(
            clientToken: clientToken, 
            ipAddressType: ipAddressType, 
            ipv4AddressesPerEni: ipv4AddressesPerEni, 
            name: name, 
            securityGroupIds: securityGroupIds, 
            subnetIds: subnetIds, 
            tags: tags, 
            vpcIdentifier: vpcIdentifier
        )
        return try await self.createResourceGateway(input, logger: logger)
    }

    /// Creates a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. For more information, see Listener rules in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func createRule(_ input: CreateRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateRuleResponse {
        try await self.client.execute(
            operation: "CreateRule", 
            path: "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. For more information, see Listener rules in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - action: The action for the default rule.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - listenerIdentifier: The ID or ARN of the listener.
    ///   - match: The rule match.
    ///   - name: The name of the rule. The name must be unique within the listener. The valid characters are a-z, 0-9, and hyphens (-). You can't use a hyphen as the first or last character, or immediately after another hyphen.
    ///   - priority: The priority assigned to the rule. Each rule for a specific listener must have a unique priority. The lower the priority number the higher the priority.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - tags: The tags for the rule.
    ///   - logger: Logger use during operation
    @inlinable
    public func createRule(
        action: RuleAction,
        clientToken: String? = CreateRuleRequest.idempotencyToken(),
        listenerIdentifier: String,
        match: RuleMatch,
        name: String,
        priority: Int,
        serviceIdentifier: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateRuleResponse {
        let input = CreateRuleRequest(
            action: action, 
            clientToken: clientToken, 
            listenerIdentifier: listenerIdentifier, 
            match: match, 
            name: name, 
            priority: priority, 
            serviceIdentifier: serviceIdentifier, 
            tags: tags
        )
        return try await self.createRule(input, logger: logger)
    }

    /// Creates a service. A service is any software application that can run on instances containers, or serverless functions within an account or virtual private cloud (VPC). For more information, see Services in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func createService(_ input: CreateServiceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateServiceResponse {
        try await self.client.execute(
            operation: "CreateService", 
            path: "/services", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a service. A service is any software application that can run on instances containers, or serverless functions within an account or virtual private cloud (VPC). For more information, see Services in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - authType: The type of IAM policy.    NONE: The resource does not use an IAM policy. This is the default.    AWS_IAM: The resource uses an IAM policy. When this type is used, auth is enabled and an auth policy is required.
    ///   - certificateArn: The Amazon Resource Name (ARN) of the certificate.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - customDomainName: The custom domain name of the service.
    ///   - name: The name of the service. The name must be unique within the account. The valid characters are a-z, 0-9, and hyphens (-). You can't use a hyphen as the first or last character, or immediately after another hyphen.
    ///   - tags: The tags for the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func createService(
        authType: AuthType? = nil,
        certificateArn: String? = nil,
        clientToken: String? = CreateServiceRequest.idempotencyToken(),
        customDomainName: String? = nil,
        name: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateServiceResponse {
        let input = CreateServiceRequest(
            authType: authType, 
            certificateArn: certificateArn, 
            clientToken: clientToken, 
            customDomainName: customDomainName, 
            name: name, 
            tags: tags
        )
        return try await self.createService(input, logger: logger)
    }

    /// Creates a service network. A service network is a logical boundary for a collection of services. You can associate services and VPCs with a service network. For more information, see Service networks in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func createServiceNetwork(_ input: CreateServiceNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateServiceNetworkResponse {
        try await self.client.execute(
            operation: "CreateServiceNetwork", 
            path: "/servicenetworks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a service network. A service network is a logical boundary for a collection of services. You can associate services and VPCs with a service network. For more information, see Service networks in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - authType: The type of IAM policy.    NONE: The resource does not use an IAM policy. This is the default.    AWS_IAM: The resource uses an IAM policy. When this type is used, auth is enabled and an auth policy is required.
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - name: The name of the service network. The name must be unique to the account. The valid characters are a-z, 0-9, and hyphens (-). You can't use a hyphen as the first or last character, or immediately after another hyphen.
    ///   - sharingConfig: Specify if the service network should be enabled for sharing.
    ///   - tags: The tags for the service network.
    ///   - logger: Logger use during operation
    @inlinable
    public func createServiceNetwork(
        authType: AuthType? = nil,
        clientToken: String? = CreateServiceNetworkRequest.idempotencyToken(),
        name: String,
        sharingConfig: SharingConfig? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateServiceNetworkResponse {
        let input = CreateServiceNetworkRequest(
            authType: authType, 
            clientToken: clientToken, 
            name: name, 
            sharingConfig: sharingConfig, 
            tags: tags
        )
        return try await self.createServiceNetwork(input, logger: logger)
    }

    /// Associates the specified service network with the specified resource configuration. This allows the resource configuration to receive connections through the service network, including through a service network VPC endpoint.
    @Sendable
    @inlinable
    public func createServiceNetworkResourceAssociation(_ input: CreateServiceNetworkResourceAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateServiceNetworkResourceAssociationResponse {
        try await self.client.execute(
            operation: "CreateServiceNetworkResourceAssociation", 
            path: "/servicenetworkresourceassociations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates the specified service network with the specified resource configuration. This allows the resource configuration to receive connections through the service network, including through a service network VPC endpoint.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - resourceConfigurationIdentifier: The ID of the resource configuration to associate with the service network.
    ///   - serviceNetworkIdentifier: The ID of the service network to associate with the resource configuration.
    ///   - tags: A key-value pair to associate with a resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func createServiceNetworkResourceAssociation(
        clientToken: String? = CreateServiceNetworkResourceAssociationRequest.idempotencyToken(),
        resourceConfigurationIdentifier: String,
        serviceNetworkIdentifier: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateServiceNetworkResourceAssociationResponse {
        let input = CreateServiceNetworkResourceAssociationRequest(
            clientToken: clientToken, 
            resourceConfigurationIdentifier: resourceConfigurationIdentifier, 
            serviceNetworkIdentifier: serviceNetworkIdentifier, 
            tags: tags
        )
        return try await self.createServiceNetworkResourceAssociation(input, logger: logger)
    }

    /// Associates the specified service with the specified service network. For more information, see Manage service associations in the Amazon VPC Lattice User Guide. You can't use this operation if the service and service network are already associated or if there is a disassociation or deletion in progress. If the association fails, you can retry the operation by deleting the association and recreating it. You cannot associate a service and service network that are shared with a caller. The caller must own either the service or the service network. As a result of this operation, the association is created in the service network account and the association owner account.
    @Sendable
    @inlinable
    public func createServiceNetworkServiceAssociation(_ input: CreateServiceNetworkServiceAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateServiceNetworkServiceAssociationResponse {
        try await self.client.execute(
            operation: "CreateServiceNetworkServiceAssociation", 
            path: "/servicenetworkserviceassociations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates the specified service with the specified service network. For more information, see Manage service associations in the Amazon VPC Lattice User Guide. You can't use this operation if the service and service network are already associated or if there is a disassociation or deletion in progress. If the association fails, you can retry the operation by deleting the association and recreating it. You cannot associate a service and service network that are shared with a caller. The caller must own either the service or the service network. As a result of this operation, the association is created in the service network account and the association owner account.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - serviceNetworkIdentifier: The ID or ARN of the service network. You must use an ARN if the resources are in different accounts.
    ///   - tags: The tags for the association.
    ///   - logger: Logger use during operation
    @inlinable
    public func createServiceNetworkServiceAssociation(
        clientToken: String? = CreateServiceNetworkServiceAssociationRequest.idempotencyToken(),
        serviceIdentifier: String,
        serviceNetworkIdentifier: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateServiceNetworkServiceAssociationResponse {
        let input = CreateServiceNetworkServiceAssociationRequest(
            clientToken: clientToken, 
            serviceIdentifier: serviceIdentifier, 
            serviceNetworkIdentifier: serviceNetworkIdentifier, 
            tags: tags
        )
        return try await self.createServiceNetworkServiceAssociation(input, logger: logger)
    }

    /// Associates a VPC with a service network. When you associate a VPC with the service network, it enables all the resources within that VPC to be clients and communicate with other services in the service network. For more information, see Manage VPC associations in the Amazon VPC Lattice User Guide. You can't use this operation if there is a disassociation in progress. If the association fails, retry by deleting the association and recreating it. As a result of this operation, the association gets created in the service network account and the VPC owner account. If you add a security group to the service network and VPC association, the association must continue to always have at least one security group. You can add or edit security groups at any time. However, to remove all security groups, you must first delete the association and recreate it without security groups.
    @Sendable
    @inlinable
    public func createServiceNetworkVpcAssociation(_ input: CreateServiceNetworkVpcAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateServiceNetworkVpcAssociationResponse {
        try await self.client.execute(
            operation: "CreateServiceNetworkVpcAssociation", 
            path: "/servicenetworkvpcassociations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a VPC with a service network. When you associate a VPC with the service network, it enables all the resources within that VPC to be clients and communicate with other services in the service network. For more information, see Manage VPC associations in the Amazon VPC Lattice User Guide. You can't use this operation if there is a disassociation in progress. If the association fails, retry by deleting the association and recreating it. As a result of this operation, the association gets created in the service network account and the VPC owner account. If you add a security group to the service network and VPC association, the association must continue to always have at least one security group. You can add or edit security groups at any time. However, to remove all security groups, you must first delete the association and recreate it without security groups.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - securityGroupIds: The IDs of the security groups. Security groups aren't added by default. You can add a security group to apply network level controls to control which resources in a VPC are allowed to access the service network and its services. For more information, see Control traffic to resources using security groups in the Amazon VPC User Guide.
    ///   - serviceNetworkIdentifier: The ID or ARN of the service network. You must use an ARN if the resources are in different accounts.
    ///   - tags: The tags for the association.
    ///   - vpcIdentifier: The ID of the VPC.
    ///   - logger: Logger use during operation
    @inlinable
    public func createServiceNetworkVpcAssociation(
        clientToken: String? = CreateServiceNetworkVpcAssociationRequest.idempotencyToken(),
        securityGroupIds: [String]? = nil,
        serviceNetworkIdentifier: String,
        tags: [String: String]? = nil,
        vpcIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateServiceNetworkVpcAssociationResponse {
        let input = CreateServiceNetworkVpcAssociationRequest(
            clientToken: clientToken, 
            securityGroupIds: securityGroupIds, 
            serviceNetworkIdentifier: serviceNetworkIdentifier, 
            tags: tags, 
            vpcIdentifier: vpcIdentifier
        )
        return try await self.createServiceNetworkVpcAssociation(input, logger: logger)
    }

    /// Creates a target group. A target group is a collection of targets, or compute resources, that run your application or service. A target group can only be used by a single service. For more information, see Target groups in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func createTargetGroup(_ input: CreateTargetGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateTargetGroupResponse {
        try await self.client.execute(
            operation: "CreateTargetGroup", 
            path: "/targetgroups", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a target group. A target group is a collection of targets, or compute resources, that run your application or service. A target group can only be used by a single service. For more information, see Target groups in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. If you retry a request that completed successfully using the same client token and parameters, the retry succeeds without performing any actions. If the parameters aren't identical, the retry fails.
    ///   - config: The target group configuration.
    ///   - name: The name of the target group. The name must be unique within the account. The valid characters are a-z, 0-9, and hyphens (-). You can't use a hyphen as the first or last character, or immediately after another hyphen.
    ///   - tags: The tags for the target group.
    ///   - type: The type of target group.
    ///   - logger: Logger use during operation
    @inlinable
    public func createTargetGroup(
        clientToken: String? = CreateTargetGroupRequest.idempotencyToken(),
        config: TargetGroupConfig? = nil,
        name: String,
        tags: [String: String]? = nil,
        type: TargetGroupType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateTargetGroupResponse {
        let input = CreateTargetGroupRequest(
            clientToken: clientToken, 
            config: config, 
            name: name, 
            tags: tags, 
            type: type
        )
        return try await self.createTargetGroup(input, logger: logger)
    }

    /// Deletes the specified access log subscription.
    @Sendable
    @inlinable
    public func deleteAccessLogSubscription(_ input: DeleteAccessLogSubscriptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAccessLogSubscriptionResponse {
        try await self.client.execute(
            operation: "DeleteAccessLogSubscription", 
            path: "/accesslogsubscriptions/{accessLogSubscriptionIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified access log subscription.
    ///
    /// Parameters:
    ///   - accessLogSubscriptionIdentifier: The ID or ARN of the access log subscription.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAccessLogSubscription(
        accessLogSubscriptionIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAccessLogSubscriptionResponse {
        let input = DeleteAccessLogSubscriptionRequest(
            accessLogSubscriptionIdentifier: accessLogSubscriptionIdentifier
        )
        return try await self.deleteAccessLogSubscription(input, logger: logger)
    }

    /// Deletes the specified auth policy. If an auth is set to AWS_IAM and the auth policy is deleted, all requests are denied. If you are trying to remove the auth policy completely, you must set the auth type to NONE. If auth is enabled on the resource, but no auth policy is set, all requests are denied.
    @Sendable
    @inlinable
    public func deleteAuthPolicy(_ input: DeleteAuthPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAuthPolicyResponse {
        try await self.client.execute(
            operation: "DeleteAuthPolicy", 
            path: "/authpolicy/{resourceIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified auth policy. If an auth is set to AWS_IAM and the auth policy is deleted, all requests are denied. If you are trying to remove the auth policy completely, you must set the auth type to NONE. If auth is enabled on the resource, but no auth policy is set, all requests are denied.
    ///
    /// Parameters:
    ///   - resourceIdentifier: The ID or ARN of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAuthPolicy(
        resourceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAuthPolicyResponse {
        let input = DeleteAuthPolicyRequest(
            resourceIdentifier: resourceIdentifier
        )
        return try await self.deleteAuthPolicy(input, logger: logger)
    }

    /// Deletes the specified listener.
    @Sendable
    @inlinable
    public func deleteListener(_ input: DeleteListenerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteListenerResponse {
        try await self.client.execute(
            operation: "DeleteListener", 
            path: "/services/{serviceIdentifier}/listeners/{listenerIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified listener.
    ///
    /// Parameters:
    ///   - listenerIdentifier: The ID or ARN of the listener.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteListener(
        listenerIdentifier: String,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteListenerResponse {
        let input = DeleteListenerRequest(
            listenerIdentifier: listenerIdentifier, 
            serviceIdentifier: serviceIdentifier
        )
        return try await self.deleteListener(input, logger: logger)
    }

    /// Deletes the specified resource configuration.
    @Sendable
    @inlinable
    public func deleteResourceConfiguration(_ input: DeleteResourceConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteResourceConfigurationResponse {
        try await self.client.execute(
            operation: "DeleteResourceConfiguration", 
            path: "/resourceconfigurations/{resourceConfigurationIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified resource configuration.
    ///
    /// Parameters:
    ///   - resourceConfigurationIdentifier: The ID or ARN of the resource configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteResourceConfiguration(
        resourceConfigurationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteResourceConfigurationResponse {
        let input = DeleteResourceConfigurationRequest(
            resourceConfigurationIdentifier: resourceConfigurationIdentifier
        )
        return try await self.deleteResourceConfiguration(input, logger: logger)
    }

    /// Disassociates the resource configuration from the resource VPC endpoint.
    @Sendable
    @inlinable
    public func deleteResourceEndpointAssociation(_ input: DeleteResourceEndpointAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteResourceEndpointAssociationResponse {
        try await self.client.execute(
            operation: "DeleteResourceEndpointAssociation", 
            path: "/resourceendpointassociations/{resourceEndpointAssociationIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates the resource configuration from the resource VPC endpoint.
    ///
    /// Parameters:
    ///   - resourceEndpointAssociationIdentifier: The ID or ARN of the association.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteResourceEndpointAssociation(
        resourceEndpointAssociationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteResourceEndpointAssociationResponse {
        let input = DeleteResourceEndpointAssociationRequest(
            resourceEndpointAssociationIdentifier: resourceEndpointAssociationIdentifier
        )
        return try await self.deleteResourceEndpointAssociation(input, logger: logger)
    }

    /// Deletes the specified resource gateway.
    @Sendable
    @inlinable
    public func deleteResourceGateway(_ input: DeleteResourceGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteResourceGatewayResponse {
        try await self.client.execute(
            operation: "DeleteResourceGateway", 
            path: "/resourcegateways/{resourceGatewayIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified resource gateway.
    ///
    /// Parameters:
    ///   - resourceGatewayIdentifier: The ID or ARN of the resource gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteResourceGateway(
        resourceGatewayIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteResourceGatewayResponse {
        let input = DeleteResourceGatewayRequest(
            resourceGatewayIdentifier: resourceGatewayIdentifier
        )
        return try await self.deleteResourceGateway(input, logger: logger)
    }

    /// Deletes the specified resource policy.
    @Sendable
    @inlinable
    public func deleteResourcePolicy(_ input: DeleteResourcePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteResourcePolicyResponse {
        try await self.client.execute(
            operation: "DeleteResourcePolicy", 
            path: "/resourcepolicy/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified resource policy.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteResourcePolicy(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteResourcePolicyResponse {
        let input = DeleteResourcePolicyRequest(
            resourceArn: resourceArn
        )
        return try await self.deleteResourcePolicy(input, logger: logger)
    }

    /// Deletes a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. You can delete additional listener rules, but you cannot delete the default rule. For more information, see Listener rules in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func deleteRule(_ input: DeleteRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteRuleResponse {
        try await self.client.execute(
            operation: "DeleteRule", 
            path: "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a listener rule. Each listener has a default rule for checking connection requests, but you can define additional rules. Each rule consists of a priority, one or more actions, and one or more conditions. You can delete additional listener rules, but you cannot delete the default rule. For more information, see Listener rules in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - listenerIdentifier: The ID or ARN of the listener.
    ///   - ruleIdentifier: The ID or ARN of the rule.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteRule(
        listenerIdentifier: String,
        ruleIdentifier: String,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteRuleResponse {
        let input = DeleteRuleRequest(
            listenerIdentifier: listenerIdentifier, 
            ruleIdentifier: ruleIdentifier, 
            serviceIdentifier: serviceIdentifier
        )
        return try await self.deleteRule(input, logger: logger)
    }

    /// Deletes a service. A service can't be deleted if it's associated with a service network. If you delete a service, all resources related to the service, such as the resource policy, auth policy, listeners, listener rules, and access log subscriptions, are also deleted. For more information, see Delete a service in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func deleteService(_ input: DeleteServiceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteServiceResponse {
        try await self.client.execute(
            operation: "DeleteService", 
            path: "/services/{serviceIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a service. A service can't be deleted if it's associated with a service network. If you delete a service, all resources related to the service, such as the resource policy, auth policy, listeners, listener rules, and access log subscriptions, are also deleted. For more information, see Delete a service in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteService(
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteServiceResponse {
        let input = DeleteServiceRequest(
            serviceIdentifier: serviceIdentifier
        )
        return try await self.deleteService(input, logger: logger)
    }

    /// Deletes a service network. You can only delete the service network if there is no service or VPC associated with it. If you delete a service network, all resources related to the service network, such as the resource policy, auth policy, and access log subscriptions, are also deleted. For more information, see Delete a service network in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func deleteServiceNetwork(_ input: DeleteServiceNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteServiceNetworkResponse {
        try await self.client.execute(
            operation: "DeleteServiceNetwork", 
            path: "/servicenetworks/{serviceNetworkIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a service network. You can only delete the service network if there is no service or VPC associated with it. If you delete a service network, all resources related to the service network, such as the resource policy, auth policy, and access log subscriptions, are also deleted. For more information, see Delete a service network in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - serviceNetworkIdentifier: The ID or ARN of the service network.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteServiceNetwork(
        serviceNetworkIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteServiceNetworkResponse {
        let input = DeleteServiceNetworkRequest(
            serviceNetworkIdentifier: serviceNetworkIdentifier
        )
        return try await self.deleteServiceNetwork(input, logger: logger)
    }

    /// Deletes the association between a service network and a resource configuration.
    @Sendable
    @inlinable
    public func deleteServiceNetworkResourceAssociation(_ input: DeleteServiceNetworkResourceAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteServiceNetworkResourceAssociationResponse {
        try await self.client.execute(
            operation: "DeleteServiceNetworkResourceAssociation", 
            path: "/servicenetworkresourceassociations/{serviceNetworkResourceAssociationIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the association between a service network and a resource configuration.
    ///
    /// Parameters:
    ///   - serviceNetworkResourceAssociationIdentifier: The ID of the association.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteServiceNetworkResourceAssociation(
        serviceNetworkResourceAssociationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteServiceNetworkResourceAssociationResponse {
        let input = DeleteServiceNetworkResourceAssociationRequest(
            serviceNetworkResourceAssociationIdentifier: serviceNetworkResourceAssociationIdentifier
        )
        return try await self.deleteServiceNetworkResourceAssociation(input, logger: logger)
    }

    /// Deletes the association between a service and a service network. This operation fails if an association is still in progress.
    @Sendable
    @inlinable
    public func deleteServiceNetworkServiceAssociation(_ input: DeleteServiceNetworkServiceAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteServiceNetworkServiceAssociationResponse {
        try await self.client.execute(
            operation: "DeleteServiceNetworkServiceAssociation", 
            path: "/servicenetworkserviceassociations/{serviceNetworkServiceAssociationIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the association between a service and a service network. This operation fails if an association is still in progress.
    ///
    /// Parameters:
    ///   - serviceNetworkServiceAssociationIdentifier: The ID or ARN of the association.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteServiceNetworkServiceAssociation(
        serviceNetworkServiceAssociationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteServiceNetworkServiceAssociationResponse {
        let input = DeleteServiceNetworkServiceAssociationRequest(
            serviceNetworkServiceAssociationIdentifier: serviceNetworkServiceAssociationIdentifier
        )
        return try await self.deleteServiceNetworkServiceAssociation(input, logger: logger)
    }

    /// Disassociates the VPC from the service network. You can't disassociate the VPC if there is a create or update association in progress.
    @Sendable
    @inlinable
    public func deleteServiceNetworkVpcAssociation(_ input: DeleteServiceNetworkVpcAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteServiceNetworkVpcAssociationResponse {
        try await self.client.execute(
            operation: "DeleteServiceNetworkVpcAssociation", 
            path: "/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates the VPC from the service network. You can't disassociate the VPC if there is a create or update association in progress.
    ///
    /// Parameters:
    ///   - serviceNetworkVpcAssociationIdentifier: The ID or ARN of the association.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteServiceNetworkVpcAssociation(
        serviceNetworkVpcAssociationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteServiceNetworkVpcAssociationResponse {
        let input = DeleteServiceNetworkVpcAssociationRequest(
            serviceNetworkVpcAssociationIdentifier: serviceNetworkVpcAssociationIdentifier
        )
        return try await self.deleteServiceNetworkVpcAssociation(input, logger: logger)
    }

    /// Deletes a target group. You can't delete a target group if it is used in a listener rule or if the target group creation is in progress.
    @Sendable
    @inlinable
    public func deleteTargetGroup(_ input: DeleteTargetGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteTargetGroupResponse {
        try await self.client.execute(
            operation: "DeleteTargetGroup", 
            path: "/targetgroups/{targetGroupIdentifier}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a target group. You can't delete a target group if it is used in a listener rule or if the target group creation is in progress.
    ///
    /// Parameters:
    ///   - targetGroupIdentifier: The ID or ARN of the target group.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteTargetGroup(
        targetGroupIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteTargetGroupResponse {
        let input = DeleteTargetGroupRequest(
            targetGroupIdentifier: targetGroupIdentifier
        )
        return try await self.deleteTargetGroup(input, logger: logger)
    }

    /// Deregisters the specified targets from the specified target group.
    @Sendable
    @inlinable
    public func deregisterTargets(_ input: DeregisterTargetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeregisterTargetsResponse {
        try await self.client.execute(
            operation: "DeregisterTargets", 
            path: "/targetgroups/{targetGroupIdentifier}/deregistertargets", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deregisters the specified targets from the specified target group.
    ///
    /// Parameters:
    ///   - targetGroupIdentifier: The ID or ARN of the target group.
    ///   - targets: The targets to deregister.
    ///   - logger: Logger use during operation
    @inlinable
    public func deregisterTargets(
        targetGroupIdentifier: String,
        targets: [Target],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeregisterTargetsResponse {
        let input = DeregisterTargetsRequest(
            targetGroupIdentifier: targetGroupIdentifier, 
            targets: targets
        )
        return try await self.deregisterTargets(input, logger: logger)
    }

    /// Retrieves information about the specified access log subscription.
    @Sendable
    @inlinable
    public func getAccessLogSubscription(_ input: GetAccessLogSubscriptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAccessLogSubscriptionResponse {
        try await self.client.execute(
            operation: "GetAccessLogSubscription", 
            path: "/accesslogsubscriptions/{accessLogSubscriptionIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified access log subscription.
    ///
    /// Parameters:
    ///   - accessLogSubscriptionIdentifier: The ID or ARN of the access log subscription.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAccessLogSubscription(
        accessLogSubscriptionIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAccessLogSubscriptionResponse {
        let input = GetAccessLogSubscriptionRequest(
            accessLogSubscriptionIdentifier: accessLogSubscriptionIdentifier
        )
        return try await self.getAccessLogSubscription(input, logger: logger)
    }

    /// Retrieves information about the auth policy for the specified service or service network.
    @Sendable
    @inlinable
    public func getAuthPolicy(_ input: GetAuthPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAuthPolicyResponse {
        try await self.client.execute(
            operation: "GetAuthPolicy", 
            path: "/authpolicy/{resourceIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the auth policy for the specified service or service network.
    ///
    /// Parameters:
    ///   - resourceIdentifier: The ID or ARN of the service network or service.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAuthPolicy(
        resourceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAuthPolicyResponse {
        let input = GetAuthPolicyRequest(
            resourceIdentifier: resourceIdentifier
        )
        return try await self.getAuthPolicy(input, logger: logger)
    }

    /// Retrieves information about the specified listener for the specified service.
    @Sendable
    @inlinable
    public func getListener(_ input: GetListenerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetListenerResponse {
        try await self.client.execute(
            operation: "GetListener", 
            path: "/services/{serviceIdentifier}/listeners/{listenerIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified listener for the specified service.
    ///
    /// Parameters:
    ///   - listenerIdentifier: The ID or ARN of the listener.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func getListener(
        listenerIdentifier: String,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetListenerResponse {
        let input = GetListenerRequest(
            listenerIdentifier: listenerIdentifier, 
            serviceIdentifier: serviceIdentifier
        )
        return try await self.getListener(input, logger: logger)
    }

    /// Retrieves information about the specified resource configuration.
    @Sendable
    @inlinable
    public func getResourceConfiguration(_ input: GetResourceConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourceConfigurationResponse {
        try await self.client.execute(
            operation: "GetResourceConfiguration", 
            path: "/resourceconfigurations/{resourceConfigurationIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified resource configuration.
    ///
    /// Parameters:
    ///   - resourceConfigurationIdentifier: The ID of the resource configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourceConfiguration(
        resourceConfigurationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourceConfigurationResponse {
        let input = GetResourceConfigurationRequest(
            resourceConfigurationIdentifier: resourceConfigurationIdentifier
        )
        return try await self.getResourceConfiguration(input, logger: logger)
    }

    /// Retrieves information about the specified resource gateway.
    @Sendable
    @inlinable
    public func getResourceGateway(_ input: GetResourceGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourceGatewayResponse {
        try await self.client.execute(
            operation: "GetResourceGateway", 
            path: "/resourcegateways/{resourceGatewayIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified resource gateway.
    ///
    /// Parameters:
    ///   - resourceGatewayIdentifier: The ID of the resource gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourceGateway(
        resourceGatewayIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourceGatewayResponse {
        let input = GetResourceGatewayRequest(
            resourceGatewayIdentifier: resourceGatewayIdentifier
        )
        return try await self.getResourceGateway(input, logger: logger)
    }

    /// Retrieves information about the specified resource policy. The resource policy is an IAM policy created on behalf of the resource owner when they share a resource.
    @Sendable
    @inlinable
    public func getResourcePolicy(_ input: GetResourcePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourcePolicyResponse {
        try await self.client.execute(
            operation: "GetResourcePolicy", 
            path: "/resourcepolicy/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified resource policy. The resource policy is an IAM policy created on behalf of the resource owner when they share a resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the service network or service.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourcePolicy(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourcePolicyResponse {
        let input = GetResourcePolicyRequest(
            resourceArn: resourceArn
        )
        return try await self.getResourcePolicy(input, logger: logger)
    }

    /// Retrieves information about the specified listener rules. You can also retrieve information about the default listener rule. For more information, see Listener rules in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func getRule(_ input: GetRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRuleResponse {
        try await self.client.execute(
            operation: "GetRule", 
            path: "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified listener rules. You can also retrieve information about the default listener rule. For more information, see Listener rules in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - listenerIdentifier: The ID or ARN of the listener.
    ///   - ruleIdentifier: The ID or ARN of the listener rule.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func getRule(
        listenerIdentifier: String,
        ruleIdentifier: String,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRuleResponse {
        let input = GetRuleRequest(
            listenerIdentifier: listenerIdentifier, 
            ruleIdentifier: ruleIdentifier, 
            serviceIdentifier: serviceIdentifier
        )
        return try await self.getRule(input, logger: logger)
    }

    /// Retrieves information about the specified service.
    @Sendable
    @inlinable
    public func getService(_ input: GetServiceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServiceResponse {
        try await self.client.execute(
            operation: "GetService", 
            path: "/services/{serviceIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified service.
    ///
    /// Parameters:
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func getService(
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceResponse {
        let input = GetServiceRequest(
            serviceIdentifier: serviceIdentifier
        )
        return try await self.getService(input, logger: logger)
    }

    /// Retrieves information about the specified service network.
    @Sendable
    @inlinable
    public func getServiceNetwork(_ input: GetServiceNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServiceNetworkResponse {
        try await self.client.execute(
            operation: "GetServiceNetwork", 
            path: "/servicenetworks/{serviceNetworkIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified service network.
    ///
    /// Parameters:
    ///   - serviceNetworkIdentifier: The ID or ARN of the service network.
    ///   - logger: Logger use during operation
    @inlinable
    public func getServiceNetwork(
        serviceNetworkIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceNetworkResponse {
        let input = GetServiceNetworkRequest(
            serviceNetworkIdentifier: serviceNetworkIdentifier
        )
        return try await self.getServiceNetwork(input, logger: logger)
    }

    /// Retrieves information about the specified association between a service network and a resource configuration.
    @Sendable
    @inlinable
    public func getServiceNetworkResourceAssociation(_ input: GetServiceNetworkResourceAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServiceNetworkResourceAssociationResponse {
        try await self.client.execute(
            operation: "GetServiceNetworkResourceAssociation", 
            path: "/servicenetworkresourceassociations/{serviceNetworkResourceAssociationIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified association between a service network and a resource configuration.
    ///
    /// Parameters:
    ///   - serviceNetworkResourceAssociationIdentifier: The ID of the association.
    ///   - logger: Logger use during operation
    @inlinable
    public func getServiceNetworkResourceAssociation(
        serviceNetworkResourceAssociationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceNetworkResourceAssociationResponse {
        let input = GetServiceNetworkResourceAssociationRequest(
            serviceNetworkResourceAssociationIdentifier: serviceNetworkResourceAssociationIdentifier
        )
        return try await self.getServiceNetworkResourceAssociation(input, logger: logger)
    }

    /// Retrieves information about the specified association between a service network and a service.
    @Sendable
    @inlinable
    public func getServiceNetworkServiceAssociation(_ input: GetServiceNetworkServiceAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServiceNetworkServiceAssociationResponse {
        try await self.client.execute(
            operation: "GetServiceNetworkServiceAssociation", 
            path: "/servicenetworkserviceassociations/{serviceNetworkServiceAssociationIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified association between a service network and a service.
    ///
    /// Parameters:
    ///   - serviceNetworkServiceAssociationIdentifier: The ID or ARN of the association.
    ///   - logger: Logger use during operation
    @inlinable
    public func getServiceNetworkServiceAssociation(
        serviceNetworkServiceAssociationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceNetworkServiceAssociationResponse {
        let input = GetServiceNetworkServiceAssociationRequest(
            serviceNetworkServiceAssociationIdentifier: serviceNetworkServiceAssociationIdentifier
        )
        return try await self.getServiceNetworkServiceAssociation(input, logger: logger)
    }

    /// Retrieves information about the specified association between a service network and a VPC.
    @Sendable
    @inlinable
    public func getServiceNetworkVpcAssociation(_ input: GetServiceNetworkVpcAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetServiceNetworkVpcAssociationResponse {
        try await self.client.execute(
            operation: "GetServiceNetworkVpcAssociation", 
            path: "/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified association between a service network and a VPC.
    ///
    /// Parameters:
    ///   - serviceNetworkVpcAssociationIdentifier: The ID or ARN of the association.
    ///   - logger: Logger use during operation
    @inlinable
    public func getServiceNetworkVpcAssociation(
        serviceNetworkVpcAssociationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetServiceNetworkVpcAssociationResponse {
        let input = GetServiceNetworkVpcAssociationRequest(
            serviceNetworkVpcAssociationIdentifier: serviceNetworkVpcAssociationIdentifier
        )
        return try await self.getServiceNetworkVpcAssociation(input, logger: logger)
    }

    /// Retrieves information about the specified target group.
    @Sendable
    @inlinable
    public func getTargetGroup(_ input: GetTargetGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetTargetGroupResponse {
        try await self.client.execute(
            operation: "GetTargetGroup", 
            path: "/targetgroups/{targetGroupIdentifier}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the specified target group.
    ///
    /// Parameters:
    ///   - targetGroupIdentifier: The ID or ARN of the target group.
    ///   - logger: Logger use during operation
    @inlinable
    public func getTargetGroup(
        targetGroupIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetTargetGroupResponse {
        let input = GetTargetGroupRequest(
            targetGroupIdentifier: targetGroupIdentifier
        )
        return try await self.getTargetGroup(input, logger: logger)
    }

    /// Lists the access log subscriptions for the specified service network or service.
    @Sendable
    @inlinable
    public func listAccessLogSubscriptions(_ input: ListAccessLogSubscriptionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAccessLogSubscriptionsResponse {
        try await self.client.execute(
            operation: "ListAccessLogSubscriptions", 
            path: "/accesslogsubscriptions", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the access log subscriptions for the specified service network or service.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - resourceIdentifier: The ID or ARN of the service network or service.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAccessLogSubscriptions(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAccessLogSubscriptionsResponse {
        let input = ListAccessLogSubscriptionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceIdentifier: resourceIdentifier
        )
        return try await self.listAccessLogSubscriptions(input, logger: logger)
    }

    /// Lists the listeners for the specified service.
    @Sendable
    @inlinable
    public func listListeners(_ input: ListListenersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListListenersResponse {
        try await self.client.execute(
            operation: "ListListeners", 
            path: "/services/{serviceIdentifier}/listeners", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the listeners for the specified service.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func listListeners(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListListenersResponse {
        let input = ListListenersRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            serviceIdentifier: serviceIdentifier
        )
        return try await self.listListeners(input, logger: logger)
    }

    /// Lists the resource configurations owned by or shared with this account.
    @Sendable
    @inlinable
    public func listResourceConfigurations(_ input: ListResourceConfigurationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListResourceConfigurationsResponse {
        try await self.client.execute(
            operation: "ListResourceConfigurations", 
            path: "/resourceconfigurations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the resource configurations owned by or shared with this account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum page size.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - resourceConfigurationGroupIdentifier: The ID of the resource configuration of type Group.
    ///   - resourceGatewayIdentifier: The ID of the resource gateway for the resource configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func listResourceConfigurations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceConfigurationGroupIdentifier: String? = nil,
        resourceGatewayIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListResourceConfigurationsResponse {
        let input = ListResourceConfigurationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceConfigurationGroupIdentifier: resourceConfigurationGroupIdentifier, 
            resourceGatewayIdentifier: resourceGatewayIdentifier
        )
        return try await self.listResourceConfigurations(input, logger: logger)
    }

    /// Lists the associations for the specified VPC endpoint.
    @Sendable
    @inlinable
    public func listResourceEndpointAssociations(_ input: ListResourceEndpointAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListResourceEndpointAssociationsResponse {
        try await self.client.execute(
            operation: "ListResourceEndpointAssociations", 
            path: "/resourceendpointassociations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the associations for the specified VPC endpoint.
    ///
    /// Parameters:
    ///   - maxResults: The maximum page size.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - resourceConfigurationIdentifier: The ID for the resource configuration associated with the VPC endpoint.
    ///   - resourceEndpointAssociationIdentifier: The ID of the association.
    ///   - vpcEndpointId: The ID of the VPC endpoint in the association.
    ///   - vpcEndpointOwner: The owner of the VPC endpoint in the association.
    ///   - logger: Logger use during operation
    @inlinable
    public func listResourceEndpointAssociations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceConfigurationIdentifier: String,
        resourceEndpointAssociationIdentifier: String? = nil,
        vpcEndpointId: String? = nil,
        vpcEndpointOwner: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListResourceEndpointAssociationsResponse {
        let input = ListResourceEndpointAssociationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceConfigurationIdentifier: resourceConfigurationIdentifier, 
            resourceEndpointAssociationIdentifier: resourceEndpointAssociationIdentifier, 
            vpcEndpointId: vpcEndpointId, 
            vpcEndpointOwner: vpcEndpointOwner
        )
        return try await self.listResourceEndpointAssociations(input, logger: logger)
    }

    /// Lists the resource gateways that you own or that were shared with you.
    @Sendable
    @inlinable
    public func listResourceGateways(_ input: ListResourceGatewaysRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListResourceGatewaysResponse {
        try await self.client.execute(
            operation: "ListResourceGateways", 
            path: "/resourcegateways", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the resource gateways that you own or that were shared with you.
    ///
    /// Parameters:
    ///   - maxResults: The maximum page size.
    ///   - nextToken: If there are additional results, a pagination token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listResourceGateways(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListResourceGatewaysResponse {
        let input = ListResourceGatewaysRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listResourceGateways(input, logger: logger)
    }

    /// Lists the rules for the specified listener.
    @Sendable
    @inlinable
    public func listRules(_ input: ListRulesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListRulesResponse {
        try await self.client.execute(
            operation: "ListRules", 
            path: "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the rules for the specified listener.
    ///
    /// Parameters:
    ///   - listenerIdentifier: The ID or ARN of the listener.
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func listRules(
        listenerIdentifier: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListRulesResponse {
        let input = ListRulesRequest(
            listenerIdentifier: listenerIdentifier, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            serviceIdentifier: serviceIdentifier
        )
        return try await self.listRules(input, logger: logger)
    }

    /// Lists the associations between a service network and a resource configuration.
    @Sendable
    @inlinable
    public func listServiceNetworkResourceAssociations(_ input: ListServiceNetworkResourceAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListServiceNetworkResourceAssociationsResponse {
        try await self.client.execute(
            operation: "ListServiceNetworkResourceAssociations", 
            path: "/servicenetworkresourceassociations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the associations between a service network and a resource configuration.
    ///
    /// Parameters:
    ///   - includeChildren: Include service network resource associations of the child resource configuration with the grouped resource configuration. The type is boolean and the default value is false.
    ///   - maxResults: The maximum page size.
    ///   - nextToken: If there are additional results, a pagination token for the next page of results.
    ///   - resourceConfigurationIdentifier: The ID of the resource configuration.
    ///   - serviceNetworkIdentifier: The ID of the service network.
    ///   - logger: Logger use during operation
    @inlinable
    public func listServiceNetworkResourceAssociations(
        includeChildren: Bool? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceConfigurationIdentifier: String? = nil,
        serviceNetworkIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListServiceNetworkResourceAssociationsResponse {
        let input = ListServiceNetworkResourceAssociationsRequest(
            includeChildren: includeChildren, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceConfigurationIdentifier: resourceConfigurationIdentifier, 
            serviceNetworkIdentifier: serviceNetworkIdentifier
        )
        return try await self.listServiceNetworkResourceAssociations(input, logger: logger)
    }

    /// Lists the associations between a service network and a service. You can filter the list either by service or service network. You must provide either the service network identifier or the service identifier. Every association in Amazon VPC Lattice has a unique Amazon Resource Name (ARN), such as when a service network is associated with a VPC or when a service is associated with a service network. If the association is for a resource is shared with another account, the association includes the local account ID as the prefix in the ARN.
    @Sendable
    @inlinable
    public func listServiceNetworkServiceAssociations(_ input: ListServiceNetworkServiceAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListServiceNetworkServiceAssociationsResponse {
        try await self.client.execute(
            operation: "ListServiceNetworkServiceAssociations", 
            path: "/servicenetworkserviceassociations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the associations between a service network and a service. You can filter the list either by service or service network. You must provide either the service network identifier or the service identifier. Every association in Amazon VPC Lattice has a unique Amazon Resource Name (ARN), such as when a service network is associated with a VPC or when a service is associated with a service network. If the association is for a resource is shared with another account, the association includes the local account ID as the prefix in the ARN.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - serviceNetworkIdentifier: The ID or ARN of the service network.
    ///   - logger: Logger use during operation
    @inlinable
    public func listServiceNetworkServiceAssociations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        serviceIdentifier: String? = nil,
        serviceNetworkIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListServiceNetworkServiceAssociationsResponse {
        let input = ListServiceNetworkServiceAssociationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            serviceIdentifier: serviceIdentifier, 
            serviceNetworkIdentifier: serviceNetworkIdentifier
        )
        return try await self.listServiceNetworkServiceAssociations(input, logger: logger)
    }

    /// Lists the associations between a service network and a VPC. You can filter the list either by VPC or service network. You must provide either the ID of the service network identifier or the ID of the VPC.
    @Sendable
    @inlinable
    public func listServiceNetworkVpcAssociations(_ input: ListServiceNetworkVpcAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListServiceNetworkVpcAssociationsResponse {
        try await self.client.execute(
            operation: "ListServiceNetworkVpcAssociations", 
            path: "/servicenetworkvpcassociations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the associations between a service network and a VPC. You can filter the list either by VPC or service network. You must provide either the ID of the service network identifier or the ID of the VPC.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - serviceNetworkIdentifier: The ID or ARN of the service network.
    ///   - vpcIdentifier: The ID or ARN of the VPC.
    ///   - logger: Logger use during operation
    @inlinable
    public func listServiceNetworkVpcAssociations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        serviceNetworkIdentifier: String? = nil,
        vpcIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListServiceNetworkVpcAssociationsResponse {
        let input = ListServiceNetworkVpcAssociationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            serviceNetworkIdentifier: serviceNetworkIdentifier, 
            vpcIdentifier: vpcIdentifier
        )
        return try await self.listServiceNetworkVpcAssociations(input, logger: logger)
    }

    /// Lists the associations between a service network and a VPC endpoint.
    @Sendable
    @inlinable
    public func listServiceNetworkVpcEndpointAssociations(_ input: ListServiceNetworkVpcEndpointAssociationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListServiceNetworkVpcEndpointAssociationsResponse {
        try await self.client.execute(
            operation: "ListServiceNetworkVpcEndpointAssociations", 
            path: "/servicenetworkvpcendpointassociations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the associations between a service network and a VPC endpoint.
    ///
    /// Parameters:
    ///   - maxResults: The maximum page size.
    ///   - nextToken: If there are additional results, a pagination token for the next page of results.
    ///   - serviceNetworkIdentifier: The ID of the service network associated with the VPC endpoint.
    ///   - logger: Logger use during operation
    @inlinable
    public func listServiceNetworkVpcEndpointAssociations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        serviceNetworkIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListServiceNetworkVpcEndpointAssociationsResponse {
        let input = ListServiceNetworkVpcEndpointAssociationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            serviceNetworkIdentifier: serviceNetworkIdentifier
        )
        return try await self.listServiceNetworkVpcEndpointAssociations(input, logger: logger)
    }

    /// Lists the service networks owned by or shared with this account. The account ID in the ARN shows which account owns the service network.
    @Sendable
    @inlinable
    public func listServiceNetworks(_ input: ListServiceNetworksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListServiceNetworksResponse {
        try await self.client.execute(
            operation: "ListServiceNetworks", 
            path: "/servicenetworks", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the service networks owned by or shared with this account. The account ID in the ARN shows which account owns the service network.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listServiceNetworks(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListServiceNetworksResponse {
        let input = ListServiceNetworksRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listServiceNetworks(input, logger: logger)
    }

    /// Lists the services owned by the caller account or shared with the caller account.
    @Sendable
    @inlinable
    public func listServices(_ input: ListServicesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListServicesResponse {
        try await self.client.execute(
            operation: "ListServices", 
            path: "/services", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the services owned by the caller account or shared with the caller account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listServices(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListServicesResponse {
        let input = ListServicesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listServices(input, logger: logger)
    }

    /// Lists the tags for the specified resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the tags for the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Lists your target groups. You can narrow your search by using the filters below in your request.
    @Sendable
    @inlinable
    public func listTargetGroups(_ input: ListTargetGroupsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTargetGroupsResponse {
        try await self.client.execute(
            operation: "ListTargetGroups", 
            path: "/targetgroups", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists your target groups. You can narrow your search by using the filters below in your request.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - targetGroupType: The target group type.
    ///   - vpcIdentifier: The ID or ARN of the VPC.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTargetGroups(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        targetGroupType: TargetGroupType? = nil,
        vpcIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTargetGroupsResponse {
        let input = ListTargetGroupsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            targetGroupType: targetGroupType, 
            vpcIdentifier: vpcIdentifier
        )
        return try await self.listTargetGroups(input, logger: logger)
    }

    /// Lists the targets for the target group. By default, all targets are included. You can use this API to check the health status of targets. You can also ﬁlter the results by target.
    @Sendable
    @inlinable
    public func listTargets(_ input: ListTargetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTargetsResponse {
        try await self.client.execute(
            operation: "ListTargets", 
            path: "/targetgroups/{targetGroupIdentifier}/listtargets", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists the targets for the target group. By default, all targets are included. You can use this API to check the health status of targets. You can also ﬁlter the results by target.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - nextToken: A pagination token for the next page of results.
    ///   - targetGroupIdentifier: The ID or ARN of the target group.
    ///   - targets: The targets.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTargets(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        targetGroupIdentifier: String,
        targets: [Target]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTargetsResponse {
        let input = ListTargetsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            targetGroupIdentifier: targetGroupIdentifier, 
            targets: targets
        )
        return try await self.listTargets(input, logger: logger)
    }

    /// Creates or updates the auth policy. The policy string in JSON must not contain newlines or blank lines. For more information, see Auth policies in the Amazon VPC Lattice User Guide.
    @Sendable
    @inlinable
    public func putAuthPolicy(_ input: PutAuthPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutAuthPolicyResponse {
        try await self.client.execute(
            operation: "PutAuthPolicy", 
            path: "/authpolicy/{resourceIdentifier}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates or updates the auth policy. The policy string in JSON must not contain newlines or blank lines. For more information, see Auth policies in the Amazon VPC Lattice User Guide.
    ///
    /// Parameters:
    ///   - policy: The auth policy. The policy string in JSON must not contain newlines or blank lines.
    ///   - resourceIdentifier: The ID or ARN of the service network or service for which the policy is created.
    ///   - logger: Logger use during operation
    @inlinable
    public func putAuthPolicy(
        policy: String,
        resourceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutAuthPolicyResponse {
        let input = PutAuthPolicyRequest(
            policy: policy, 
            resourceIdentifier: resourceIdentifier
        )
        return try await self.putAuthPolicy(input, logger: logger)
    }

    /// Attaches a resource-based permission policy to a service or service network. The policy must contain the same actions and condition statements as the Amazon Web Services Resource Access Manager permission for sharing services and service networks.
    @Sendable
    @inlinable
    public func putResourcePolicy(_ input: PutResourcePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutResourcePolicyResponse {
        try await self.client.execute(
            operation: "PutResourcePolicy", 
            path: "/resourcepolicy/{resourceArn}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Attaches a resource-based permission policy to a service or service network. The policy must contain the same actions and condition statements as the Amazon Web Services Resource Access Manager permission for sharing services and service networks.
    ///
    /// Parameters:
    ///   - policy: An IAM policy. The policy string in JSON must not contain newlines or blank lines.
    ///   - resourceArn: The ID or ARN of the service network or service for which the policy is created.
    ///   - logger: Logger use during operation
    @inlinable
    public func putResourcePolicy(
        policy: String,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutResourcePolicyResponse {
        let input = PutResourcePolicyRequest(
            policy: policy, 
            resourceArn: resourceArn
        )
        return try await self.putResourcePolicy(input, logger: logger)
    }

    /// Registers the targets with the target group. If it's a Lambda target, you can only have one target in a target group.
    @Sendable
    @inlinable
    public func registerTargets(_ input: RegisterTargetsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> RegisterTargetsResponse {
        try await self.client.execute(
            operation: "RegisterTargets", 
            path: "/targetgroups/{targetGroupIdentifier}/registertargets", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Registers the targets with the target group. If it's a Lambda target, you can only have one target in a target group.
    ///
    /// Parameters:
    ///   - targetGroupIdentifier: The ID or ARN of the target group.
    ///   - targets: The targets.
    ///   - logger: Logger use during operation
    @inlinable
    public func registerTargets(
        targetGroupIdentifier: String,
        targets: [Target],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> RegisterTargetsResponse {
        let input = RegisterTargetsRequest(
            targetGroupIdentifier: targetGroupIdentifier, 
            targets: targets
        )
        return try await self.registerTargets(input, logger: logger)
    }

    /// Adds the specified tags to the specified resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds the specified tags to the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tags: The tags for the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes the specified tags from the specified resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes the specified tags from the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: The tag keys of the tags to remove.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the specified access log subscription.
    @Sendable
    @inlinable
    public func updateAccessLogSubscription(_ input: UpdateAccessLogSubscriptionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAccessLogSubscriptionResponse {
        try await self.client.execute(
            operation: "UpdateAccessLogSubscription", 
            path: "/accesslogsubscriptions/{accessLogSubscriptionIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified access log subscription.
    ///
    /// Parameters:
    ///   - accessLogSubscriptionIdentifier: The ID or ARN of the access log subscription.
    ///   - destinationArn: The Amazon Resource Name (ARN) of the access log destination.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAccessLogSubscription(
        accessLogSubscriptionIdentifier: String,
        destinationArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAccessLogSubscriptionResponse {
        let input = UpdateAccessLogSubscriptionRequest(
            accessLogSubscriptionIdentifier: accessLogSubscriptionIdentifier, 
            destinationArn: destinationArn
        )
        return try await self.updateAccessLogSubscription(input, logger: logger)
    }

    /// Updates the specified listener for the specified service.
    @Sendable
    @inlinable
    public func updateListener(_ input: UpdateListenerRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateListenerResponse {
        try await self.client.execute(
            operation: "UpdateListener", 
            path: "/services/{serviceIdentifier}/listeners/{listenerIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified listener for the specified service.
    ///
    /// Parameters:
    ///   - defaultAction: The action for the default rule.
    ///   - listenerIdentifier: The ID or ARN of the listener.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateListener(
        defaultAction: RuleAction,
        listenerIdentifier: String,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateListenerResponse {
        let input = UpdateListenerRequest(
            defaultAction: defaultAction, 
            listenerIdentifier: listenerIdentifier, 
            serviceIdentifier: serviceIdentifier
        )
        return try await self.updateListener(input, logger: logger)
    }

    /// Updates the specified resource configuration.
    @Sendable
    @inlinable
    public func updateResourceConfiguration(_ input: UpdateResourceConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateResourceConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateResourceConfiguration", 
            path: "/resourceconfigurations/{resourceConfigurationIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified resource configuration.
    ///
    /// Parameters:
    ///   - allowAssociationToShareableServiceNetwork: Indicates whether to add the resource configuration to service networks that are shared with other accounts.
    ///   - portRanges: The TCP port ranges that a consumer can use to access a resource configuration. You can separate port ranges with a comma. Example: 1-65535 or 1,2,22-30
    ///   - resourceConfigurationDefinition: Identifies the resource configuration in one of the following ways:    Amazon Resource Name (ARN) - Supported resource-types that are provisioned by Amazon Web Services services, such as RDS databases, can be identified by their ARN.    Domain name - Any domain name that is publicly resolvable.    IP address - For IPv4 and IPv6, only IP addresses in the VPC are supported.
    ///   - resourceConfigurationIdentifier: The ID of the resource configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateResourceConfiguration(
        allowAssociationToShareableServiceNetwork: Bool? = nil,
        portRanges: [String]? = nil,
        resourceConfigurationDefinition: ResourceConfigurationDefinition? = nil,
        resourceConfigurationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateResourceConfigurationResponse {
        let input = UpdateResourceConfigurationRequest(
            allowAssociationToShareableServiceNetwork: allowAssociationToShareableServiceNetwork, 
            portRanges: portRanges, 
            resourceConfigurationDefinition: resourceConfigurationDefinition, 
            resourceConfigurationIdentifier: resourceConfigurationIdentifier
        )
        return try await self.updateResourceConfiguration(input, logger: logger)
    }

    /// Updates the specified resource gateway.
    @Sendable
    @inlinable
    public func updateResourceGateway(_ input: UpdateResourceGatewayRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateResourceGatewayResponse {
        try await self.client.execute(
            operation: "UpdateResourceGateway", 
            path: "/resourcegateways/{resourceGatewayIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified resource gateway.
    ///
    /// Parameters:
    ///   - resourceGatewayIdentifier: The ID or ARN of the resource gateway.
    ///   - securityGroupIds: The IDs of the security groups associated with the resource gateway.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateResourceGateway(
        resourceGatewayIdentifier: String,
        securityGroupIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateResourceGatewayResponse {
        let input = UpdateResourceGatewayRequest(
            resourceGatewayIdentifier: resourceGatewayIdentifier, 
            securityGroupIds: securityGroupIds
        )
        return try await self.updateResourceGateway(input, logger: logger)
    }

    /// Updates a specified rule for the listener. You can't modify a default listener rule. To modify a default listener rule, use UpdateListener.
    @Sendable
    @inlinable
    public func updateRule(_ input: UpdateRuleRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateRuleResponse {
        try await self.client.execute(
            operation: "UpdateRule", 
            path: "/services/{serviceIdentifier}/listeners/{listenerIdentifier}/rules/{ruleIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a specified rule for the listener. You can't modify a default listener rule. To modify a default listener rule, use UpdateListener.
    ///
    /// Parameters:
    ///   - action: Information about the action for the specified listener rule.
    ///   - listenerIdentifier: The ID or ARN of the listener.
    ///   - match: The rule match.
    ///   - priority: The rule priority. A listener can't have multiple rules with the same priority.
    ///   - ruleIdentifier: The ID or ARN of the rule.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRule(
        action: RuleAction? = nil,
        listenerIdentifier: String,
        match: RuleMatch? = nil,
        priority: Int? = nil,
        ruleIdentifier: String,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateRuleResponse {
        let input = UpdateRuleRequest(
            action: action, 
            listenerIdentifier: listenerIdentifier, 
            match: match, 
            priority: priority, 
            ruleIdentifier: ruleIdentifier, 
            serviceIdentifier: serviceIdentifier
        )
        return try await self.updateRule(input, logger: logger)
    }

    /// Updates the specified service.
    @Sendable
    @inlinable
    public func updateService(_ input: UpdateServiceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateServiceResponse {
        try await self.client.execute(
            operation: "UpdateService", 
            path: "/services/{serviceIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified service.
    ///
    /// Parameters:
    ///   - authType: The type of IAM policy.    NONE: The resource does not use an IAM policy. This is the default.    AWS_IAM: The resource uses an IAM policy. When this type is used, auth is enabled and an auth policy is required.
    ///   - certificateArn: The Amazon Resource Name (ARN) of the certificate.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateService(
        authType: AuthType? = nil,
        certificateArn: String? = nil,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateServiceResponse {
        let input = UpdateServiceRequest(
            authType: authType, 
            certificateArn: certificateArn, 
            serviceIdentifier: serviceIdentifier
        )
        return try await self.updateService(input, logger: logger)
    }

    /// Updates the specified service network.
    @Sendable
    @inlinable
    public func updateServiceNetwork(_ input: UpdateServiceNetworkRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateServiceNetworkResponse {
        try await self.client.execute(
            operation: "UpdateServiceNetwork", 
            path: "/servicenetworks/{serviceNetworkIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified service network.
    ///
    /// Parameters:
    ///   - authType: The type of IAM policy.    NONE: The resource does not use an IAM policy. This is the default.    AWS_IAM: The resource uses an IAM policy. When this type is used, auth is enabled and an auth policy is required.
    ///   - serviceNetworkIdentifier: The ID or ARN of the service network.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateServiceNetwork(
        authType: AuthType,
        serviceNetworkIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateServiceNetworkResponse {
        let input = UpdateServiceNetworkRequest(
            authType: authType, 
            serviceNetworkIdentifier: serviceNetworkIdentifier
        )
        return try await self.updateServiceNetwork(input, logger: logger)
    }

    /// Updates the service network and VPC association. If you add a security group to the service network and VPC association, the association must continue to have at least one security group. You can add or edit security groups at any time. However, to remove all security groups, you must first delete the association and then recreate it without security groups.
    @Sendable
    @inlinable
    public func updateServiceNetworkVpcAssociation(_ input: UpdateServiceNetworkVpcAssociationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateServiceNetworkVpcAssociationResponse {
        try await self.client.execute(
            operation: "UpdateServiceNetworkVpcAssociation", 
            path: "/servicenetworkvpcassociations/{serviceNetworkVpcAssociationIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the service network and VPC association. If you add a security group to the service network and VPC association, the association must continue to have at least one security group. You can add or edit security groups at any time. However, to remove all security groups, you must first delete the association and then recreate it without security groups.
    ///
    /// Parameters:
    ///   - securityGroupIds: The IDs of the security groups.
    ///   - serviceNetworkVpcAssociationIdentifier: The ID or ARN of the association.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateServiceNetworkVpcAssociation(
        securityGroupIds: [String],
        serviceNetworkVpcAssociationIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateServiceNetworkVpcAssociationResponse {
        let input = UpdateServiceNetworkVpcAssociationRequest(
            securityGroupIds: securityGroupIds, 
            serviceNetworkVpcAssociationIdentifier: serviceNetworkVpcAssociationIdentifier
        )
        return try await self.updateServiceNetworkVpcAssociation(input, logger: logger)
    }

    /// Updates the specified target group.
    @Sendable
    @inlinable
    public func updateTargetGroup(_ input: UpdateTargetGroupRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateTargetGroupResponse {
        try await self.client.execute(
            operation: "UpdateTargetGroup", 
            path: "/targetgroups/{targetGroupIdentifier}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified target group.
    ///
    /// Parameters:
    ///   - healthCheck: The health check configuration.
    ///   - targetGroupIdentifier: The ID or ARN of the target group.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateTargetGroup(
        healthCheck: HealthCheckConfig,
        targetGroupIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateTargetGroupResponse {
        let input = UpdateTargetGroupRequest(
            healthCheck: healthCheck, 
            targetGroupIdentifier: targetGroupIdentifier
        )
        return try await self.updateTargetGroup(input, logger: logger)
    }
}

extension VPCLattice {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: VPCLattice, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension VPCLattice {
    /// Return PaginatorSequence for operation ``listAccessLogSubscriptions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccessLogSubscriptionsPaginator(
        _ input: ListAccessLogSubscriptionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAccessLogSubscriptionsRequest, ListAccessLogSubscriptionsResponse> {
        return .init(
            input: input,
            command: self.listAccessLogSubscriptions,
            inputKey: \ListAccessLogSubscriptionsRequest.nextToken,
            outputKey: \ListAccessLogSubscriptionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAccessLogSubscriptions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - resourceIdentifier: The ID or ARN of the service network or service.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccessLogSubscriptionsPaginator(
        maxResults: Int? = nil,
        resourceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAccessLogSubscriptionsRequest, ListAccessLogSubscriptionsResponse> {
        let input = ListAccessLogSubscriptionsRequest(
            maxResults: maxResults, 
            resourceIdentifier: resourceIdentifier
        )
        return self.listAccessLogSubscriptionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listListeners(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listListenersPaginator(
        _ input: ListListenersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListListenersRequest, ListListenersResponse> {
        return .init(
            input: input,
            command: self.listListeners,
            inputKey: \ListListenersRequest.nextToken,
            outputKey: \ListListenersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listListeners(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger used for logging
    @inlinable
    public func listListenersPaginator(
        maxResults: Int? = nil,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListListenersRequest, ListListenersResponse> {
        let input = ListListenersRequest(
            maxResults: maxResults, 
            serviceIdentifier: serviceIdentifier
        )
        return self.listListenersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listResourceConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceConfigurationsPaginator(
        _ input: ListResourceConfigurationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListResourceConfigurationsRequest, ListResourceConfigurationsResponse> {
        return .init(
            input: input,
            command: self.listResourceConfigurations,
            inputKey: \ListResourceConfigurationsRequest.nextToken,
            outputKey: \ListResourceConfigurationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listResourceConfigurations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum page size.
    ///   - resourceConfigurationGroupIdentifier: The ID of the resource configuration of type Group.
    ///   - resourceGatewayIdentifier: The ID of the resource gateway for the resource configuration.
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceConfigurationsPaginator(
        maxResults: Int? = nil,
        resourceConfigurationGroupIdentifier: String? = nil,
        resourceGatewayIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListResourceConfigurationsRequest, ListResourceConfigurationsResponse> {
        let input = ListResourceConfigurationsRequest(
            maxResults: maxResults, 
            resourceConfigurationGroupIdentifier: resourceConfigurationGroupIdentifier, 
            resourceGatewayIdentifier: resourceGatewayIdentifier
        )
        return self.listResourceConfigurationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listResourceEndpointAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceEndpointAssociationsPaginator(
        _ input: ListResourceEndpointAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListResourceEndpointAssociationsRequest, ListResourceEndpointAssociationsResponse> {
        return .init(
            input: input,
            command: self.listResourceEndpointAssociations,
            inputKey: \ListResourceEndpointAssociationsRequest.nextToken,
            outputKey: \ListResourceEndpointAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listResourceEndpointAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum page size.
    ///   - resourceConfigurationIdentifier: The ID for the resource configuration associated with the VPC endpoint.
    ///   - resourceEndpointAssociationIdentifier: The ID of the association.
    ///   - vpcEndpointId: The ID of the VPC endpoint in the association.
    ///   - vpcEndpointOwner: The owner of the VPC endpoint in the association.
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceEndpointAssociationsPaginator(
        maxResults: Int? = nil,
        resourceConfigurationIdentifier: String,
        resourceEndpointAssociationIdentifier: String? = nil,
        vpcEndpointId: String? = nil,
        vpcEndpointOwner: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListResourceEndpointAssociationsRequest, ListResourceEndpointAssociationsResponse> {
        let input = ListResourceEndpointAssociationsRequest(
            maxResults: maxResults, 
            resourceConfigurationIdentifier: resourceConfigurationIdentifier, 
            resourceEndpointAssociationIdentifier: resourceEndpointAssociationIdentifier, 
            vpcEndpointId: vpcEndpointId, 
            vpcEndpointOwner: vpcEndpointOwner
        )
        return self.listResourceEndpointAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listResourceGateways(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceGatewaysPaginator(
        _ input: ListResourceGatewaysRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListResourceGatewaysRequest, ListResourceGatewaysResponse> {
        return .init(
            input: input,
            command: self.listResourceGateways,
            inputKey: \ListResourceGatewaysRequest.nextToken,
            outputKey: \ListResourceGatewaysResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listResourceGateways(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum page size.
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceGatewaysPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListResourceGatewaysRequest, ListResourceGatewaysResponse> {
        let input = ListResourceGatewaysRequest(
            maxResults: maxResults
        )
        return self.listResourceGatewaysPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listRules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listRulesPaginator(
        _ input: ListRulesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListRulesRequest, ListRulesResponse> {
        return .init(
            input: input,
            command: self.listRules,
            inputKey: \ListRulesRequest.nextToken,
            outputKey: \ListRulesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listRules(_:logger:)``.
    ///
    /// - Parameters:
    ///   - listenerIdentifier: The ID or ARN of the listener.
    ///   - maxResults: The maximum number of results to return.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - logger: Logger used for logging
    @inlinable
    public func listRulesPaginator(
        listenerIdentifier: String,
        maxResults: Int? = nil,
        serviceIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListRulesRequest, ListRulesResponse> {
        let input = ListRulesRequest(
            listenerIdentifier: listenerIdentifier, 
            maxResults: maxResults, 
            serviceIdentifier: serviceIdentifier
        )
        return self.listRulesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listServiceNetworkResourceAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceNetworkResourceAssociationsPaginator(
        _ input: ListServiceNetworkResourceAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListServiceNetworkResourceAssociationsRequest, ListServiceNetworkResourceAssociationsResponse> {
        return .init(
            input: input,
            command: self.listServiceNetworkResourceAssociations,
            inputKey: \ListServiceNetworkResourceAssociationsRequest.nextToken,
            outputKey: \ListServiceNetworkResourceAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listServiceNetworkResourceAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - includeChildren: Include service network resource associations of the child resource configuration with the grouped resource configuration. The type is boolean and the default value is false.
    ///   - maxResults: The maximum page size.
    ///   - resourceConfigurationIdentifier: The ID of the resource configuration.
    ///   - serviceNetworkIdentifier: The ID of the service network.
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceNetworkResourceAssociationsPaginator(
        includeChildren: Bool? = nil,
        maxResults: Int? = nil,
        resourceConfigurationIdentifier: String? = nil,
        serviceNetworkIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListServiceNetworkResourceAssociationsRequest, ListServiceNetworkResourceAssociationsResponse> {
        let input = ListServiceNetworkResourceAssociationsRequest(
            includeChildren: includeChildren, 
            maxResults: maxResults, 
            resourceConfigurationIdentifier: resourceConfigurationIdentifier, 
            serviceNetworkIdentifier: serviceNetworkIdentifier
        )
        return self.listServiceNetworkResourceAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listServiceNetworkServiceAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceNetworkServiceAssociationsPaginator(
        _ input: ListServiceNetworkServiceAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListServiceNetworkServiceAssociationsRequest, ListServiceNetworkServiceAssociationsResponse> {
        return .init(
            input: input,
            command: self.listServiceNetworkServiceAssociations,
            inputKey: \ListServiceNetworkServiceAssociationsRequest.nextToken,
            outputKey: \ListServiceNetworkServiceAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listServiceNetworkServiceAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - serviceIdentifier: The ID or ARN of the service.
    ///   - serviceNetworkIdentifier: The ID or ARN of the service network.
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceNetworkServiceAssociationsPaginator(
        maxResults: Int? = nil,
        serviceIdentifier: String? = nil,
        serviceNetworkIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListServiceNetworkServiceAssociationsRequest, ListServiceNetworkServiceAssociationsResponse> {
        let input = ListServiceNetworkServiceAssociationsRequest(
            maxResults: maxResults, 
            serviceIdentifier: serviceIdentifier, 
            serviceNetworkIdentifier: serviceNetworkIdentifier
        )
        return self.listServiceNetworkServiceAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listServiceNetworkVpcAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceNetworkVpcAssociationsPaginator(
        _ input: ListServiceNetworkVpcAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListServiceNetworkVpcAssociationsRequest, ListServiceNetworkVpcAssociationsResponse> {
        return .init(
            input: input,
            command: self.listServiceNetworkVpcAssociations,
            inputKey: \ListServiceNetworkVpcAssociationsRequest.nextToken,
            outputKey: \ListServiceNetworkVpcAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listServiceNetworkVpcAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - serviceNetworkIdentifier: The ID or ARN of the service network.
    ///   - vpcIdentifier: The ID or ARN of the VPC.
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceNetworkVpcAssociationsPaginator(
        maxResults: Int? = nil,
        serviceNetworkIdentifier: String? = nil,
        vpcIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListServiceNetworkVpcAssociationsRequest, ListServiceNetworkVpcAssociationsResponse> {
        let input = ListServiceNetworkVpcAssociationsRequest(
            maxResults: maxResults, 
            serviceNetworkIdentifier: serviceNetworkIdentifier, 
            vpcIdentifier: vpcIdentifier
        )
        return self.listServiceNetworkVpcAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listServiceNetworkVpcEndpointAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceNetworkVpcEndpointAssociationsPaginator(
        _ input: ListServiceNetworkVpcEndpointAssociationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListServiceNetworkVpcEndpointAssociationsRequest, ListServiceNetworkVpcEndpointAssociationsResponse> {
        return .init(
            input: input,
            command: self.listServiceNetworkVpcEndpointAssociations,
            inputKey: \ListServiceNetworkVpcEndpointAssociationsRequest.nextToken,
            outputKey: \ListServiceNetworkVpcEndpointAssociationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listServiceNetworkVpcEndpointAssociations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum page size.
    ///   - serviceNetworkIdentifier: The ID of the service network associated with the VPC endpoint.
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceNetworkVpcEndpointAssociationsPaginator(
        maxResults: Int? = nil,
        serviceNetworkIdentifier: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListServiceNetworkVpcEndpointAssociationsRequest, ListServiceNetworkVpcEndpointAssociationsResponse> {
        let input = ListServiceNetworkVpcEndpointAssociationsRequest(
            maxResults: maxResults, 
            serviceNetworkIdentifier: serviceNetworkIdentifier
        )
        return self.listServiceNetworkVpcEndpointAssociationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listServiceNetworks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceNetworksPaginator(
        _ input: ListServiceNetworksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListServiceNetworksRequest, ListServiceNetworksResponse> {
        return .init(
            input: input,
            command: self.listServiceNetworks,
            inputKey: \ListServiceNetworksRequest.nextToken,
            outputKey: \ListServiceNetworksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listServiceNetworks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listServiceNetworksPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListServiceNetworksRequest, ListServiceNetworksResponse> {
        let input = ListServiceNetworksRequest(
            maxResults: maxResults
        )
        return self.listServiceNetworksPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listServices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listServicesPaginator(
        _ input: ListServicesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListServicesRequest, ListServicesResponse> {
        return .init(
            input: input,
            command: self.listServices,
            inputKey: \ListServicesRequest.nextToken,
            outputKey: \ListServicesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listServices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - logger: Logger used for logging
    @inlinable
    public func listServicesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListServicesRequest, ListServicesResponse> {
        let input = ListServicesRequest(
            maxResults: maxResults
        )
        return self.listServicesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTargetGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTargetGroupsPaginator(
        _ input: ListTargetGroupsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTargetGroupsRequest, ListTargetGroupsResponse> {
        return .init(
            input: input,
            command: self.listTargetGroups,
            inputKey: \ListTargetGroupsRequest.nextToken,
            outputKey: \ListTargetGroupsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTargetGroups(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - targetGroupType: The target group type.
    ///   - vpcIdentifier: The ID or ARN of the VPC.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTargetGroupsPaginator(
        maxResults: Int? = nil,
        targetGroupType: TargetGroupType? = nil,
        vpcIdentifier: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTargetGroupsRequest, ListTargetGroupsResponse> {
        let input = ListTargetGroupsRequest(
            maxResults: maxResults, 
            targetGroupType: targetGroupType, 
            vpcIdentifier: vpcIdentifier
        )
        return self.listTargetGroupsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTargets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listTargetsPaginator(
        _ input: ListTargetsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTargetsRequest, ListTargetsResponse> {
        return .init(
            input: input,
            command: self.listTargets,
            inputKey: \ListTargetsRequest.nextToken,
            outputKey: \ListTargetsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTargets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of results to return.
    ///   - targetGroupIdentifier: The ID or ARN of the target group.
    ///   - targets: The targets.
    ///   - logger: Logger used for logging
    @inlinable
    public func listTargetsPaginator(
        maxResults: Int? = nil,
        targetGroupIdentifier: String,
        targets: [Target]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTargetsRequest, ListTargetsResponse> {
        let input = ListTargetsRequest(
            maxResults: maxResults, 
            targetGroupIdentifier: targetGroupIdentifier, 
            targets: targets
        )
        return self.listTargetsPaginator(input, logger: logger)
    }
}

extension VPCLattice.ListAccessLogSubscriptionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListAccessLogSubscriptionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resourceIdentifier: self.resourceIdentifier
        )
    }
}

extension VPCLattice.ListListenersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListListenersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            serviceIdentifier: self.serviceIdentifier
        )
    }
}

extension VPCLattice.ListResourceConfigurationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListResourceConfigurationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resourceConfigurationGroupIdentifier: self.resourceConfigurationGroupIdentifier,
            resourceGatewayIdentifier: self.resourceGatewayIdentifier
        )
    }
}

extension VPCLattice.ListResourceEndpointAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListResourceEndpointAssociationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resourceConfigurationIdentifier: self.resourceConfigurationIdentifier,
            resourceEndpointAssociationIdentifier: self.resourceEndpointAssociationIdentifier,
            vpcEndpointId: self.vpcEndpointId,
            vpcEndpointOwner: self.vpcEndpointOwner
        )
    }
}

extension VPCLattice.ListResourceGatewaysRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListResourceGatewaysRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension VPCLattice.ListRulesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListRulesRequest {
        return .init(
            listenerIdentifier: self.listenerIdentifier,
            maxResults: self.maxResults,
            nextToken: token,
            serviceIdentifier: self.serviceIdentifier
        )
    }
}

extension VPCLattice.ListServiceNetworkResourceAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListServiceNetworkResourceAssociationsRequest {
        return .init(
            includeChildren: self.includeChildren,
            maxResults: self.maxResults,
            nextToken: token,
            resourceConfigurationIdentifier: self.resourceConfigurationIdentifier,
            serviceNetworkIdentifier: self.serviceNetworkIdentifier
        )
    }
}

extension VPCLattice.ListServiceNetworkServiceAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListServiceNetworkServiceAssociationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            serviceIdentifier: self.serviceIdentifier,
            serviceNetworkIdentifier: self.serviceNetworkIdentifier
        )
    }
}

extension VPCLattice.ListServiceNetworkVpcAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListServiceNetworkVpcAssociationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            serviceNetworkIdentifier: self.serviceNetworkIdentifier,
            vpcIdentifier: self.vpcIdentifier
        )
    }
}

extension VPCLattice.ListServiceNetworkVpcEndpointAssociationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListServiceNetworkVpcEndpointAssociationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            serviceNetworkIdentifier: self.serviceNetworkIdentifier
        )
    }
}

extension VPCLattice.ListServiceNetworksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListServiceNetworksRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension VPCLattice.ListServicesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListServicesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension VPCLattice.ListTargetGroupsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListTargetGroupsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            targetGroupType: self.targetGroupType,
            vpcIdentifier: self.vpcIdentifier
        )
    }
}

extension VPCLattice.ListTargetsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> VPCLattice.ListTargetsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            targetGroupIdentifier: self.targetGroupIdentifier,
            targets: self.targets
        )
    }
}
